#include "thread_pool.h"
#include <iostream>
#include <vector>
#include <numeric>
#include <chrono>
#include <cassert>
#include <cmath>
// void comprehensive_thread_pool_test() {
//     // 测试1：基本功能测试
//     {
//         thread_pool pool(4);
//         auto future = pool.submit([] { return std::string("Hello ThreadPool!"); });
//         std::cout << "基本测试结果: " << future.get() << std::endl;
//     }

//     // 测试2：返回值类型测试
//     {
//         thread_pool pool(4);
//         auto int_fut = pool.submit([]
//                                    { return 42; });
//         auto double_fut = pool.submit([]
//                                       { return 3.14159; });

//         // 修复：通过值捕获移动double_fut（C++14移动捕获）
//         auto string_fut = pool.submit([my_double = std::move(double_fut)]() mutable
//                                       { return std::string("π ≈ ") + std::to_string(my_double.get()); });

//         std::cout << "多类型测试: "
//                   << int_fut.get() << ", "
//                   << string_fut.get() << std::endl;
//     }

//     // 测试3：并行计算性能测试
//     {
//         const int task_count = 1000;
//         thread_pool pool(4);
//         std::vector<std::future<double>> futures;

//         auto start = std::chrono::high_resolution_clock::now();
//         for (int i = 0; i < task_count; ++i)
//         {
//             futures.emplace_back(pool.submit([i]
//                                              { return std::sin(i * 0.01); }));
//         }

//         double sum = 0;
//         for (auto &f : futures)
//         {
//             sum += f.get();
//         }
//         auto end = std::chrono::high_resolution_clock::now();

//         std::cout << "并行计算" << task_count << "个sin任务总和: " << sum
//                   << " 耗时: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
//                   << "ms" << std::endl;
//     }

//     // 测试4：线程安全测试
//     {
//         thread_pool pool(4);
//         std::atomic<int> counter(0);
//         const int increment_times = 10000;
//         const int thread_count = 10;
//         std::vector<std::future<void>> futures;

//         for (int i = 0; i < thread_count; ++i)
//         {
//             futures.emplace_back(pool.submit([&]
//                                              {
//                 for(int j = 0; j < increment_times; ++j) {
//                     ++counter;
//                 } }));
//         }

//         for (auto &f : futures)
//             f.wait();
//         std::cout << "线程安全测试结果: " << counter
//                   << " (预期: " << increment_times * thread_count << ")" << std::endl;
//     }

//     // 测试5：异常处理测试
//     {
//         thread_pool pool(4);
//         auto future = pool.submit([]
//                                   {
//             throw std::runtime_error("测试异常");
//             return 0; });

//         try
//         {
//             future.get();
//             std::cout << "异常测试失败: 未捕获异常" << std::endl;
//         }
//         catch (const std::exception &e)
//         {
//             std::cout << "成功捕获异常: " << e.what() << std::endl;
//         }
//     }

//     // 测试6：任务依赖测试
//     {
//         thread_pool pool(4);
//         auto future1 = pool.submit([]
//                                    { return 20; });
//         auto future2 = pool.submit([&future1]
//                                    { return future1.get() + 22; });
//         std::cout << "任务依赖测试结果: " << future2.get() << " (预期: 42)" << std::endl;
//     }

//     // 测试7：压力测试
//     {
//         const int heavy_task_count = 5000;
//         thread_pool pool(4);
//         std::vector<std::future<int>> futures;

//         std::cout << "开始压力测试（提交" << heavy_task_count << "个任务）..." << std::endl;
//         auto start = std::chrono::steady_clock::now();

//         for (int i = 0; i < heavy_task_count; ++i)
//         {
//             futures.emplace_back(pool.submit([i]
//                                              {
//                 std::this_thread::sleep_for(std::chrono::microseconds(100));
//                 return i * i; }));
//         }

//         int total = 0;
//         for (auto &f : futures)
//         {
//             total += f.get();
//         }

//         auto end = std::chrono::steady_clock::now();
//         std::cout << "压力测试完成，结果校验: " << total
//                   << " 总耗时: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
//                   << "ms" << std::endl;
//     }
// }

void test()
{
    thread_pool pool(4);
    pool.submit([]{ std::cout << "dotask\n"; });
}
int main()
{
    // comprehensive_thread_pool_test();
    test();
    return 0;
}